home *** CD-ROM | disk | FTP | other *** search
/ Game.EXE 2001 January / Game.EXE_01_2001.iso / demos / Blade of Darkness / data1.cab / Program_Executable_Files / Lib / GameStateAux.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2000-11-16  |  17.5 KB  |  480 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 1.5)
  3.  
  4. import os
  5. import cPickle
  6. import BBLib
  7. import Bladex
  8. import Reference
  9. import Breakings
  10. import PickInit
  11. import types
  12. import ObjStore
  13. import cStringIO
  14. PickDataBase = { }
  15. LoadedPickledData = { }
  16. aux_dir = '.'
  17. FixDataBase = []
  18.  
  19. def LoadGlobalCompVars(filename, dest_dict):
  20.     file = open(filename)
  21.     u = cPickle.Unpickler(file)
  22.     u.persistent_load = persistent_load
  23.     ret = u.load()
  24.     file.close()
  25.     for i in ret.keys():
  26.         dest_dict[i] = ret[i]
  27.     
  28.  
  29.  
  30. def InitGameState(aux_dir):
  31.     global PickDataBase, PickDataBase
  32.     PickDataBase = { }
  33.     filename = '%s/PickDataBase.dat' % (aux_dir,)
  34.     funcfile = open(filename, 'rt')
  35.     p = cPickle.Unpickler(funcfile)
  36.     PickDataBase = p.load()
  37.     funcfile.close()
  38.     print 'PickDataBase read'
  39.  
  40.  
  41. def CleanLoadTemp():
  42.     global PickDataBase, LoadedPickledData, LoadedPickledData
  43.     PickDataBase = { }
  44.     LoadedPickledData = { }
  45.     LoadedPickledData = { }
  46.  
  47.  
  48. def EndGameState(aux_dir):
  49.     filename = '%s/PickDataBase.dat' % (aux_dir,)
  50.     funcfile = open(filename, 'wt')
  51.     p = cPickle.Pickler(funcfile)
  52.     p.dump(PickDataBase)
  53.     funcfile.close()
  54.     print 'PickDataBase written'
  55.  
  56.  
  57. def persistent_id(obj):
  58.     ret = None
  59.     
  60.     try:
  61.         ret = obj.persistent_id()
  62.     except AttributeError:
  63.         pass
  64.     except Exception:
  65.         exc = None
  66.         print 'GameStateAux.persistent_id()', exc
  67.  
  68.     return ret
  69.  
  70.  
  71. def persistent_load(obj_id):
  72.     if ObjStore.ObjectsStore.has_key(obj_id):
  73.         return ObjStore.ObjectsStore[obj_id]
  74.         filename = '%s/%s.dat' % ('f', obj_id)
  75.         dat = GetPickledData(filename)
  76.         
  77.         try:
  78.             LoadedPickledData[dat.persistent_id()] = dat
  79.         except KeyError:
  80.             LoadedPickledData[obj_id] = dat
  81.  
  82.         return dat
  83.     
  84.  
  85.  
  86. def SavePickData(filename, data):
  87.     if PickDataBase.has_key(filename):
  88.         return None
  89.     
  90.     string_file = cStringIO.StringIO()
  91.     p = cPickle.Pickler(string_file)
  92.     p.persistent_id = persistent_id
  93.     p.dump(data)
  94.     PickDataBase[filename] = string_file.getvalue()
  95.  
  96.  
  97. def GetPickledData(filename):
  98.     string_file = cStringIO.StringIO(PickDataBase[filename])
  99.     u = cPickle.Unpickler(string_file)
  100.     u.persistent_load = persistent_load
  101.     ret = u.load()
  102.     return ret
  103.  
  104.  
  105. def GetPickledObjects(filename):
  106.     '''Loads the ObjStore file'''
  107.     global FixDataBase
  108.     f = open(filename, 'rt')
  109.     u = cPickle.Unpickler(f)
  110.     ret = u.load()
  111.     f.close()
  112.     for i in FixDataBase:
  113.         print 'Fixing', i
  114.         func_id = i[0]
  115.         ob_id = func_id[0]
  116.         if ObjStore.ObjectsStore.has_key(ob_id):
  117.             cl = ObjStore.ObjectsStore[ob_id]
  118.             print i[1]
  119.             cl_to_assign = None
  120.             if i[4] == 'Entity':
  121.                 cl_to_assign = Bladex.GetEntity(i[1])
  122.                 print 'Found Entity', cl_to_assign
  123.             else:
  124.                 cl_to_assign = ObjStore.ObjectsStore[i[1]]
  125.                 print 'Found class', cl_to_assign
  126.             if cl_to_assign:
  127.                 if i[4] == 'Object':
  128.                     exec 'cl_to_assign.' + i[2] + '=cl'
  129.                     print 'Fixed relationship for object', i
  130.                     print 'Executed cl_to_assign.' + str(i[2]) + '=cl'
  131.                     print 'cl_to_assign:', cl_to_assign
  132.                     print 'cl:', cl
  133.                 else:
  134.                     exec 'cl_to_assign.' + i[2] + '=cl.' + func_id[1]
  135.                     print 'Fixed relationship for function', i
  136.             else:
  137.                 print "Can't fix FixDataBase.", ob_id, 'Not found.', i
  138.         else:
  139.             print "Can't fix FixDataBase.", ob_id, 'Not found.'
  140.     
  141.     FixDataBase = []
  142.  
  143.  
  144. def LoadAutoBODs(dir):
  145.     files = os.listdir(dir)
  146.     for i in files:
  147.         pass
  148.     
  149.  
  150.  
  151. def LoadMMPs(files):
  152.     for i in files:
  153.         BBLib.ReadMMP(i)
  154.     
  155.  
  156.  
  157. def LoadAlphaBMPs(files):
  158.     for i in files:
  159.         Bladex.ReadAlphaBitMap(i[0], i[1])
  160.     
  161.  
  162.  
  163. def LoadBMPs(files):
  164.     for i in files:
  165.         Bladex.ReadBitMap(i[0], i[1])
  166.     
  167.  
  168.  
  169. def LoadBODs(files):
  170.     for i in files:
  171.         BBLib.ReadBOD(i)
  172.     
  173.  
  174.  
  175. def AddWeaponToInventory(inv, weapon_name):
  176.     object_flag = Reference.GiveObjectFlag(weapon_name)
  177.     if object_flag == Reference.OBJ_BOW:
  178.         inv.AddBow(weapon_name)
  179.     else:
  180.         flag = Reference.GiveWeaponFlag(weapon_name)
  181.         inv.AddWeapon(weapon_name, flag)
  182.  
  183.  
  184. def LinkRight(weapon_name, inv, owner):
  185.     weapon = Bladex.GetEntity(weapon_name)
  186.     owner.Unlink(weapon)
  187.     inv.LinkRightHand(weapon_name)
  188.  
  189.  
  190. def LinkLeft(weapon_name, inv, owner):
  191.     weapon = Bladex.GetEntity(weapon_name)
  192.     owner.Unlink(weapon)
  193.     inv.LinkLeftHand(weapon_name)
  194.  
  195.  
  196. def LinkBack(weapon_name, inv, owner):
  197.     weapon = Bladex.GetEntity(weapon_name)
  198.     owner.Unlink(weapon)
  199.     inv.LinkBack(weapon_name)
  200.  
  201.  
  202. def LinkLeft2B(weapon_name, inv, owner):
  203.     weapon = Bladex.GetEntity(weapon_name)
  204.     owner.Unlink(weapon)
  205.     inv.LinkLeftHand2(weapon_name)
  206.  
  207.  
  208. def AddQuiverToInventory(inv, quiver_name):
  209.     obj = Bladex.GetEntity(quiver_name)
  210.     inv.AddQuiver(quiver_name)
  211.  
  212.  
  213. def SaveFunctionAux(func):
  214.     
  215.     try:
  216.         func_type = type(func)
  217.         if func_type == types.MethodType:
  218.             ob_id = func.im_self.persistent_id()
  219.             print 'Saving Method:', ob_id, func.im_func.func_name
  220.             return ('m', (ob_id, func.im_func.func_name))
  221.         elif func_type == types.FunctionType:
  222.             return ('f', (func.func_name, GetFunctionFile(func)))
  223.         elif func_type == types.BuiltinFunctionType:
  224.             if not (func.__self__):
  225.                 return ('cf', (func.__name__, None))
  226.             else:
  227.                 return ('cf', (func.__name__, func.__self__.Name))
  228.         
  229.         return ('n', (None, None))
  230.     except Exception:
  231.         exc = None
  232.         print 'Exception in SaveFunctionAux()', exc, ' with function', func
  233.         return ('n', (None, None))
  234.  
  235.  
  236.  
  237. def LoadFunctionAux(func_id_ex, res_obj = None, res_field = None, aux = None):
  238.     assign_func = None
  239.     if type(func_id_ex) != types.TupleType:
  240.         print 'LoadFunctionAux() ERROR, invalid parameters', type(func_id_ex)
  241.         return None
  242.     
  243.     func_id = func_id_ex[1]
  244.     func_kind = func_id_ex[0]
  245.     if func_kind == 'm':
  246.         ob_id = func_id[0]
  247.         if ObjStore.ObjectsStore.has_key(ob_id):
  248.             cl = ObjStore.ObjectsStore[ob_id]
  249.             assign_func = eval('cl.' + func_id[1])
  250.         elif res_obj is not None:
  251.             if type(res_obj) == type(Bladex.GetEntity(0)):
  252.                 print 'FixDataBase.append() Entity->', func_id, res_obj.Name, res_field, ob_id
  253.                 FixDataBase.append((func_id, res_obj.Name, res_field, ob_id, 'Entity'))
  254.             else:
  255.                 print 'FixDataBase.append() class->', func_id, res_obj.ObjId, res_field, ob_id
  256.                 FixDataBase.append((func_id, res_obj.ObjId, res_field, ob_id, None))
  257.         else:
  258.             import pdb
  259.             pdb.set_trace()
  260.             print 'Can not find object to add to FixDataBase', func_id_ex
  261.     elif func_kind == 'f':
  262.         assign_func = PickInit.ConstFunction(func_id[0], func_id[1])
  263.     elif func_kind == 'cf':
  264.         assign_func = PickInit.ConstCFunction(func_id[0], func_id[1])
  265.     elif func_kind == 'n':
  266.         assign_func = None
  267.     
  268.     if res_obj:
  269.         exec 'res_obj.' + res_field + '=assign_func'
  270.     else:
  271.         return assign_func
  272.  
  273.  
  274. def SaveObjectAux(obj):
  275.     
  276.     try:
  277.         return ('o', (obj.persistent_id(), None))
  278.     except Exception:
  279.         exc = None
  280.         print 'Exception in SaveObjectAux()', exc, ' with object', obj
  281.         return ('n', (None, None))
  282.  
  283.  
  284.  
  285. def LoadObjectAux(obj_id_ex, res_obj = None, res_field = None, aux = None):
  286.     assign_obj = None
  287.     obj_id = obj_id_ex[1]
  288.     obj_kind = obj_id_ex[0]
  289.     if obj_kind == 'o':
  290.         ob_id = obj_id[0]
  291.         if ObjStore.ObjectsStore.has_key(ob_id):
  292.             assign_obj = ObjStore.ObjectsStore[ob_id]
  293.         elif res_obj is not None:
  294.             print 'FixDataBase.append() Entity->', obj_id, res_field, ob_id
  295.             FixDataBase.append((obj_id, res_obj.ObjId, res_field, ob_id, 'Object'))
  296.         else:
  297.             print 'Can not find object to add to FixDataBase', obj_id_ex
  298.             import pdb
  299.             pdb.set_trace()
  300.     elif func_kind == 'n':
  301.         assign_obj = None
  302.     
  303.     if res_obj:
  304.         exec 'res_obj.' + res_field + '=assign_obj'
  305.     else:
  306.         return assign_obj
  307.  
  308.  
  309. def SaveEntityAux(ent):
  310.     if ent:
  311.         
  312.         try:
  313.             return ent.Name
  314.         except:
  315.             print 'Error getting entity name', ent
  316.             return None
  317.  
  318.     
  319.     return None
  320.  
  321.  
  322. def LoadEntityAux(ent_id):
  323.     if ent_id:
  324.         return Bladex.GetEntity(ent_id)
  325.     
  326.     return None
  327.  
  328.  
  329. def SaveExtraDataAux(file, aux_dir):
  330.     
  331.     try:
  332.         import ExtraData
  333.         filename = '%s/ExtraData.dat' % (aux_dir,)
  334.         if ExtraData.SaveExtraData(filename):
  335.             file.write('try:\n')
  336.             file.write('  GameStateAux.LoadExtraDataAux("%s")\n' % (filename,))
  337.             file.write('except:\n')
  338.             file.write('  print "Can not load ExtraData"\n\n')
  339.     except:
  340.         pass
  341.  
  342.  
  343.  
  344. def LoadExtraDataAux(filename):
  345.     import ExtraData
  346.     ExtraData.LoadExtraData(filename)
  347.  
  348.  
  349. def GetAllBases(check_class):
  350.     ret = []
  351.     bases = check_class.__bases__
  352.     for i in bases:
  353.         ret.append(i)
  354.         bases_i = GetAllBases(i)
  355.         for j in bases_i:
  356.             ret.append(j)
  357.         
  358.     
  359.     return ret
  360.  
  361.  
  362. def GetNewMembers(check_class):
  363.     '''Obtiene los miembros nuevos de la clase y de sus clases base'''
  364.     class_dict = { }
  365.     bases = GetAllBases(check_class.__class__)
  366.     for i in bases:
  367.         class_dict.update(i.__dict__)
  368.     
  369.     class_dict.update(check_class.__class__.__dict__)
  370.     check_dict = check_class.__dict__
  371.     new_members = { }
  372.     for j in check_dict.keys():
  373.         pass
  374.     
  375.     return new_members
  376.  
  377.  
  378. def SaveNewMembers(check_class):
  379.     if type(check_class) != types.InstanceType:
  380.         return ()
  381.     
  382.     ret = []
  383.     entity_type = type(Bladex.GetEntity(0))
  384.     members = GetNewMembers(check_class)
  385.     members_keys = members.keys()
  386.     for i in members_keys:
  387.         member = members[i]
  388.         member_t = type(member)
  389.         print check_class, i, member_t
  390.         if member_t == types.FunctionType or member_t == types.MethodType:
  391.             ret.append(('Function', i, SaveFunctionAux(member)))
  392.         elif member_t == entity_type:
  393.             ret.append(('Entity', i, SaveEntityAux(member)))
  394.         else:
  395.             ret.append(('Other', i, member))
  396.     
  397.     return tuple(ret)
  398.  
  399.  
  400. def LoadNewMembers(mod_class, new_members):
  401.     
  402.     try:
  403.         for i in new_members:
  404.             if i[0] == 'Function':
  405.                 LoadFunctionAux(i[2], mod_class, i[1])
  406.             elif i[1] == 'Entity':
  407.                 mod_class.__dict__[i[1]] = LoadEntityAux(i[2])
  408.             else:
  409.                 mod_class.__dict__[i[1]] = i[2]
  410.     except Exception:
  411.         exc = None
  412.         print 'LoadNewMembers() Error', exc, mod_class, new_members
  413.  
  414.  
  415.  
  416. def GetBaseMethod(check_class, method_name, bases):
  417.     for i in bases:
  418.         
  419.         try:
  420.             tmp_string = "i.__dict__['" + method_name + "']"
  421.             return eval(tmp_string)
  422.         except:
  423.             0
  424.             bases
  425.  
  426.     
  427.     return None
  428.  
  429.  
  430. def GetAlteredMethods(check_class):
  431.     '''Obtiene los metodos de una clase y de sus clases base que han sido cambiados'''
  432.     class_dict = { }
  433.     bases = GetAllBases(check_class.__class__)
  434.     for i in bases:
  435.         class_dict.update(i.__dict__)
  436.     
  437.     class_dict.update(check_class.__class__.__dict__)
  438.     altered_beast = { }
  439.     for j in class_dict.keys():
  440.         member = eval('check_class.' + j)
  441.         if type(member) == types.MethodType:
  442.             found_func = eval('member.im_func')
  443.             tmp_string = "check_class.__class__.__dict__['" + j + "']"
  444.             
  445.             try:
  446.                 reference_func = eval(tmp_string)
  447.             except:
  448.                 0
  449.                 class_dict.keys()
  450.                 0
  451.                 reference_func = GetBaseMethod(check_class, j, bases)
  452.  
  453.             if found_func != reference_func:
  454.                 altered_beast[j] = member
  455.             
  456.         
  457.     
  458.     return altered_beast
  459.  
  460.  
  461. def GetFunctionFile(f):
  462.     if not f:
  463.         return 'Error, None is not  a function'
  464.     
  465.     
  466.     try:
  467.         import string
  468.         s = str(f.func_code)
  469.         s2 = string.split(s, '"')
  470.         func_path = s2[1]
  471.         import os
  472.         filename = os.path.split(func_path)[1]
  473.         filename_noext = os.path.splitext(filename)[0]
  474.         return filename_noext
  475.     except e:
  476.         print 'Exception in GetFunctionFile', e
  477.         return 'Error getting lib'
  478.  
  479.  
  480.